const app = getApp();

// Markdown解析函数
function parseMarkdown(text) {
    if (!text) return '';

    // 保存原始文本用于后续处理
    const originalText = text;

    try {
        // 替换标题
        text = text.replace(/#{1,6}\s+(.*?)(?:\n|$)/g, (match, content) => {
            const level = match.trim().indexOf(' ');
            return `<view class="md-title md-h${level}">${content}</view>`;
        });

        // 替换粗体
        text = text.replace(/\*\*(.*?)\*\*/g, '<text class="md-bold">$1</text>');

        // 替换斜体
        text = text.replace(/\*(.*?)\*/g, '<text class="md-italic">$1</text>');

        // 替换代码块
        text = text.replace(/```([\s\S]*?)```/g, (match, code) => {
            return `<view class="md-code-block">${code.trim()}</view>`;
        });

        // 替换行内代码
        text = text.replace(/`([^`]+)`/g, '<text class="md-code">$1</text>');

        // 替换列表项
        text = text.replace(/^[\*\-]\s+(.*?)(?:\n|$)/gm, '<view class="md-list-item">• $1</view>');

        // 替换有序列表项
        text = text.replace(/^\d+\.\s+(.*?)(?:\n|$)/gm, (match, content, index) => {
            return `<view class="md-list-item">${index + 1}. ${content}</view>`;
        });

        // 替换链接
        text = text.replace(/\[([^\]]+)\]\(([^)]+)\)/g, '<text class="md-link" data-href="$2">$1</text>');

        // 替换换行符
        text = text.replace(/\n/g, '<br/>');

        return text;
    } catch (error) {
        console.error('Markdown解析错误:', error);
        return originalText; // 如果解析出错，返回原始文本
    }
}

// 获取原始文本（去除HTML标签）
function getOriginalText(htmlText) {
    if (!htmlText) return '';

    try {
        // 简单的HTML标签移除
        return htmlText.replace(/<[^>]*>/g, '')
            .replace(/&lt;/g, '<')
            .replace(/&gt;/g, '>')
            .replace(/&amp;/g, '&')
            .replace(/&quot;/g, '"')
            .replace(/&apos;/g, "'")
            .replace(/<br\/>/g, '\n');
    } catch (error) {
        console.error('获取原始文本错误:', error);
        return htmlText;
    }
}

Page({
    data: {
        messages: [],
        inputValue: '',
        scrollTop: 0,
        loading: false,
        userInfo: {},
        currentStreamingMessage: '',
        isStreaming: false,
        showTypingIndicator: false,
        quickQuestions: [
            "考研英语如何备考？",
            "考研数学难点有哪些？",
            "考研政治如何得高分？",
            "考研专业课如何准备？",
            "考研复试需要注意什么？"
        ],
        dynamicQuestions: [],
        showQuickQuestions: true
    },

    onLoad: function() {
        // 获取用户信息
        if (app.globalData && app.globalData.userInfo) {
            this.setData({
                userInfo: app.globalData.userInfo
            });
        }

        // 添加欢迎消息
        setTimeout(() => {
            this.addAIMessage("你好！我是你的AI助手，可以回答你关于考研的任何问题。请问有什么可以帮助你的吗？");
        }, 500);

        // 监听页面滚动
        this.setAutoScroll(true);
    },

    onShow: function() {
        // 如果用户信息更新，则更新页面
        if (app.globalData && app.globalData.userInfo &&
            (!this.data.userInfo || this.data.userInfo.id !== app.globalData.userInfo.id)) {
            this.setData({
                userInfo: app.globalData.userInfo
            });
        }
    },

    // 设置自动滚动状态
    setAutoScroll(enabled) {
        this.autoScroll = enabled;
    },

    // 滚动到底部
    scrollToBottom() {
        if (this.autoScroll) {
            this.setData({
                scrollTop: 100000 // 使用一个足够大的数字确保滚动到底部
            });
        }
    },

    // 用户手动滚动时触发
    onScrollEvent(e) {
        // 获取滚动位置信息
        const { scrollTop, scrollHeight, deltaY } = e.detail;
        const query = wx.createSelectorQuery().in(this);

        query.select('.chat-messages').boundingClientRect(rect => {
            // 如果用户向上滚动，禁用自动滚动
            if (deltaY < 0) {
                this.setAutoScroll(false);
            }

            // 如果滚动到接近底部，重新启用自动滚动
            const isNearBottom = scrollTop + rect.height >= scrollHeight - 100;
            if (isNearBottom) {
                this.setAutoScroll(true);
            }
        }).exec();
    },

    onInput(e) {
        this.setData({
            inputValue: e.detail.value
        });
    },

    clearInput() {
        this.setData({
            inputValue: ''
        });
    },

    useQuickQuestion(e) {
        const question = e.currentTarget.dataset.question;
        this.setData({
            inputValue: question
        });
        this.sendMessage();
    },

    addUserMessage(message) {
        const newMessages = [...this.data.messages, {
            text: message,
            isUser: true,
            time: new Date().getTime(),
            id: `msg-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`
        }];

        this.setData({
            messages: newMessages
        });
        this.scrollToBottom();
        return newMessages;
    },

    addAIMessage(message) {
        // 解析Markdown
        const parsedText = parseMarkdown(message);

        const newMessages = [...this.data.messages, {
            text: message,
            parsedText: parsedText,
            isUser: false,
            time: new Date().getTime(),
            id: `msg-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`
        }];

        this.setData({
            messages: newMessages,
            showTypingIndicator: false
        });
        this.scrollToBottom();
        return newMessages;
    },

    // 更新流式消息
    updateStreamingMessage(text) {
        // 解析Markdown
        const parsedText = parseMarkdown(text);

        this.setData({
            currentStreamingMessage: parsedText,
            showTypingIndicator: false
        });
        this.scrollToBottom();
    },

    // 完成流式消息
    finishStreamingMessage() {
        if (this.data.currentStreamingMessage) {
            // 获取原始文本
            const originalText = getOriginalText(this.data.currentStreamingMessage);

            // 添加到消息列表
            this.addAIMessage(originalText);

            // 根据对话内容生成相关问题
            this.generateRelatedQuestions(originalText);

            this.setData({
                currentStreamingMessage: '',
                isStreaming: false,
                showTypingIndicator: false
            });
        } else {
            this.setData({
                isStreaming: false,
                showTypingIndicator: false
            });
        }
    },

    // 根据对话内容生成相关问题
    generateRelatedQuestions(latestAIResponse) {
        // 如果当前有很多消息，我们可以基于最近的对话内容生成相关问题
        if (this.data.messages.length > 2) {
            // 获取最近的AI回复
            const recentMessages = this.data.messages.slice(-4); // 获取最近4条消息

            // 根据最近的对话内容，生成相关问题
            this.generateQuestionsFromContext(recentMessages, latestAIResponse);
        }
    },

    // 从上下文生成相关问题
    generateQuestionsFromContext(recentMessages, latestResponse) {
        // 这里可以实现更复杂的逻辑，比如调用后端API生成相关问题
        // 简单起见，这里我们使用一些规则来生成问题

        // 提取最近一条用户消息的主题
        let userMessage = "";
        for (let i = recentMessages.length - 1; i >= 0; i--) {
            if (recentMessages[i].isUser) {
                userMessage = recentMessages[i].text;
                break;
            }
        }

        // 从AI响应中提取关键词（简化版）
        const keywords = this.extractKeywords(latestResponse);

        // 根据提取的关键词，生成相关问题
        const dynamicQuestions = [];

        // 考研相关的通用问题模板
        const questionTemplates = [
            "关于{keyword}有什么具体的复习方法？",
            "{keyword}需要注意哪些细节？",
            "{keyword}有哪些常见误区？",
            "{keyword}和其他科目如何平衡？",
            "有没有针对{keyword}的推荐资料？"
        ];

        // 为每个关键词生成问题
        keywords.forEach(keyword => {
            // 随机选择问题模板
            const template = questionTemplates[Math.floor(Math.random() * questionTemplates.length)];
            const question = template.replace('{keyword}', keyword);

            // 避免重复问题
            if (!dynamicQuestions.includes(question)) {
                dynamicQuestions.push(question);
            }
        });

        // 如果生成的问题不足，添加一些通用问题
        if (dynamicQuestions.length < 3) {
            if (!dynamicQuestions.includes("还有其他问题想了解吗？")) {
                dynamicQuestions.push("还有其他问题想了解吗？");
            }
            if (!dynamicQuestions.includes("需要更详细的解释吗？")) {
                dynamicQuestions.push("需要更详细的解释吗？");
            }
        }

        // 最多显示5个问题
        const finalQuestions = dynamicQuestions.slice(0, 5);

        // 更新动态问题
        this.setData({
            dynamicQuestions: finalQuestions,
            showQuickQuestions: true // 自动显示快速提问
        });
    },

    // 从文本中提取关键词（简化版）
    extractKeywords(text) {
        if (!text) return ["考研", "备考", "复习"];

        // 考研相关的关键词列表
        const keywordsList = [
            "英语", "数学", "政治", "专业课", "复试",
            "阅读", "写作", "翻译", "词汇", "语法",
            "高数", "线代", "概率论", "统计", "逻辑",
            "马原", "毛中特", "思修", "法理学", "史纲",
            "面试", "复习", "备考", "考试", "报考"
        ];

        // 识别文本中出现的关键词
        const foundKeywords = [];
        keywordsList.forEach(keyword => {
            if (text.includes(keyword) && !foundKeywords.includes(keyword)) {
                foundKeywords.push(keyword);
            }
        });

        // 如果没有找到关键词，返回默认关键词
        return foundKeywords.length > 0 ? foundKeywords : ["考研", "备考", "复习"];
    },

    sendMessage() {
        const message = this.data.inputValue.trim();
        if (message === '') return;
        if (this.data.isStreaming) return; // 防止重复发送

        // 清空输入框并添加用户消息
        this.setData({
            inputValue: '',
            isStreaming: true,
            currentStreamingMessage: '',
            showTypingIndicator: true
        });

        this.addUserMessage(message);

        // 自动滚动到底部
        this.setAutoScroll(true);
        this.scrollToBottom();

        // 使用流式输出模拟
        this.streamResponse(message);
    },

    // 模拟流式响应
    streamResponse(message) {
        // 显示正在输入提示
        this.setData({
            showTypingIndicator: true
        });

        // 发送请求到后端
        wx.request({
            url: `http://localhost:9420/ai/chat?message=${encodeURIComponent(message)}`,
            method: 'GET',
            success: (res) => {
                if (res.statusCode === 200 && res.data) {
                    // 隐藏输入提示
                    this.setData({
                        showTypingIndicator: false
                    });

                    // 获取完整响应
                    let aiResponse = res.data.message || res.data;
                    if (typeof aiResponse === 'object') {
                        aiResponse = JSON.stringify(aiResponse);
                    }

                    // 使用优化的流式输出
                    this.enhancedStreamingResponse(aiResponse);
                } else {
                    // 处理错误响应
                    const errorMessage = `抱歉，我遇到了一些问题。错误代码：${res.statusCode}`;
                    this.setData({
                        isStreaming: false,
                        showTypingIndicator: false
                    });
                    this.addAIMessage(errorMessage);
                    console.error('API响应错误:', res);
                }
            },
            fail: (err) => {
                this.setData({
                    isStreaming: false,
                    showTypingIndicator: false
                });

                // 处理请求失败
                const errorMessage = `抱歉，网络连接出现问题。请检查您的网络连接后重试。`;
                this.addAIMessage(errorMessage);
                console.error('请求失败:', err);
            }
        });
    },

    // 增强的流式输出实现
    enhancedStreamingResponse(fullResponse) {
        if (!fullResponse) {
            this.finishStreamingMessage();
            return;
        }

        // 将文本分成句子和段落，以保持语义完整性
        const segments = this.splitIntoSegments(fullResponse);
        let currentIndex = 0;
        let currentText = '';

        // 自适应输出速度 - 根据文本总长度调整
        const baseDelay = 10; // 基本延迟（毫秒）
        const textLength = fullResponse.length;
        let adaptiveDelay = baseDelay;

        // 对于较长的文本，加快速度
        if (textLength > 500) {
            adaptiveDelay = 5;
        }

        // 实现自然的打字节奏
        const timer = setInterval(() => {
            if (currentIndex < segments.length) {
                // 添加下一个语义片段
                currentText += segments[currentIndex];
                this.updateStreamingMessage(currentText);
                currentIndex++;

                // 句子结束时短暂停顿
                if (segments[currentIndex - 1].endsWith('。') ||
                    segments[currentIndex - 1].endsWith('！') ||
                    segments[currentIndex - 1].endsWith('？')) {
                    adaptiveDelay = baseDelay * 2; // 句末暂停稍长
                } else if (segments[currentIndex - 1].endsWith('，') ||
                    segments[currentIndex - 1].endsWith('；')) {
                    adaptiveDelay = baseDelay * 1.5; // 逗号暂停适中
                } else {
                    adaptiveDelay = baseDelay; // 恢复正常速度
                }

                // 适应文本长度，长文本加快输出
                if (currentText.length > 200) {
                    adaptiveDelay = Math.max(adaptiveDelay / 1.5, 2);
                }
                if (currentText.length > 500) {
                    adaptiveDelay = Math.max(adaptiveDelay / 2, 1);
                }

                // 动态调整间隔
                clearInterval(timer);
                if (currentIndex < segments.length) {
                    setTimeout(() => {
                        const nextTimer = setInterval(() => {
                            if (currentIndex < segments.length) {
                                currentText += segments[currentIndex];
                                this.updateStreamingMessage(currentText);
                                currentIndex++;
                            } else {
                                clearInterval(nextTimer);
                                this.finishStreamingMessage();
                            }
                        }, adaptiveDelay);
                    }, adaptiveDelay * 5); // 句末、逗号等停顿时间
                } else {
                    this.finishStreamingMessage();
                }
            } else {
                // 完成输出
                clearInterval(timer);
                this.finishStreamingMessage();
            }
        }, adaptiveDelay);
    },

    // 将文本分成语义单元（短语、词语等）
    splitIntoSegments(text) {
        if (!text) return [];

        // 正则表达式匹配标点符号和短语
        const segmentRegex = /([，。！？；：,.!?;:])|([^，。！？；：,.!?;:]+)/g;
        const segments = [];
        let match;

        // 提取所有匹配的段落
        while ((match = segmentRegex.exec(text)) !== null) {
            // 获取匹配的分组
            const segment = match[0];
            if (segment.trim() !== '') {
                // 进一步细分长文本段落
                if (segment.length > 15 && !segment.match(/[，。！？；：,.!?;:]/)) {
                    // 将长词组按照2-4个字一组分割
                    const subSegmentLength = Math.min(4, Math.max(2, Math.floor(segment.length / 5)));
                    for (let i = 0; i < segment.length; i += subSegmentLength) {
                        const end = Math.min(i + subSegmentLength, segment.length);
                        segments.push(segment.substring(i, end));
                    }
                } else {
                    segments.push(segment);
                }
            }
        }

        return segments;
    },

    // 模拟流式输出 (保留作为备用方案)
    simulateStreamingResponse(fullResponse) {
        if (!fullResponse) {
            this.finishStreamingMessage();
            return;
        }

        const characters = fullResponse.split('');
        let currentIndex = 0;
        let currentText = '';
        let chunkSize = 3; // 每次更新增加的字符数量

        // 设置字符输出的时间间隔（毫秒）- 降低间隔提高流畅度
        const interval = 5;

        // 创建定时器，分块输出而不是逐字输出
        const timer = setInterval(() => {
            if (currentIndex < characters.length) {
                // 确定当前块的结束位置
                const endIndex = Math.min(currentIndex + chunkSize, characters.length);
                // 添加新的字符块
                currentText += characters.slice(currentIndex, endIndex).join('');
                this.updateStreamingMessage(currentText);
                currentIndex = endIndex;

                // 动态调整块大小 - 根据内容长度逐渐增加块大小以提高流畅度
                if (currentIndex > 100) {
                    chunkSize = 5;
                } else if (currentIndex > 300) {
                    chunkSize = 8;
                }
            } else {
                // 完成输出
                clearInterval(timer);
                this.finishStreamingMessage();
            }
        }, interval);
    },

    // 重试上一条消息
    retryLastMessage() {
        if (this.data.isStreaming) return; // 防止重复发送

        // 找到最后一条用户消息
        const messages = this.data.messages;
        for (let i = messages.length - 1; i >= 0; i--) {
            if (messages[i].isUser) {
                const message = messages[i].text;

                // 移除最后的AI消息（如果有）
                if (i + 1 < messages.length && !messages[i + 1].isUser) {
                    this.setData({
                        messages: messages.slice(0, i + 1),
                        isStreaming: true,
                        currentStreamingMessage: '',
                        showTypingIndicator: true
                    });
                } else {
                    this.setData({
                        isStreaming: true,
                        currentStreamingMessage: '',
                        showTypingIndicator: true
                    });
                }

                // 自动滚动到底部
                this.setAutoScroll(true);
                this.scrollToBottom();

                // 重新发送请求
                this.streamResponse(message);
                break;
            }
        }
    },

    // 复制消息内容
    copyMessageText(e) {
        const { text } = e.currentTarget.dataset;
        if (!text) return;

        wx.setClipboardData({
            data: text,
            success: () => {
                wx.showToast({
                    title: '已复制到剪贴板',
                    icon: 'success',
                    duration: 1500
                });
            }
        });
    },

    // 分享功能
    onShareAppMessage() {
        return {
            title: 'AI智能助手 - 解答你的考研问题',
            path: '/pages/aiChat/aiChat',
            imageUrl: '/static/images/share-ai.png'
        };
    },

    // 在对话过程中显示快速提问
    showQuickQuestionsPanel() {
        this.setData({
            showQuickQuestions: true
        });
    },

    // 隐藏快速提问面板
    hideQuickQuestionsPanel() {
        this.setData({
            showQuickQuestions: false
        });
    },

    // 智能切换快速提问面板显示状态
    toggleQuickQuestions() {
        this.setData({
            showQuickQuestions: !this.data.showQuickQuestions
        });
    }
});